<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>Title</title>
</head>
<!--
字符串模版
模版字面量使用反引号 '' 而不是引号来定义字符串
let text = 'hello'
插值 模版字面量提供了一种将变量和表达式插入字符串的简单方法  该方法叫做字符串插值
变量替换 模板字面量云字符串中的变量 用真实值自动替换变量称为字符串插值
表达式替换 模板字面量允许字符串中的表达式替换

html模版
js 只有一种数值类型
整数的精度会被精确到15位 ,小数的最大数是17位,但是浮点数并不总是精确的
js的加法和级联都使用 + 运算符 数字用加法,字符串用级联
var x = 10
var y = 20
var z = x+y
NaN 属于js的保留词指示某个数不是合法数 尝试用一个非数字字符串进行除法会得到NaN
可以使用isNaN() 来确认某个值是否是个数

infinity 是js在计算数超过最大可能范围时返回的值
js整数最多只能精确到15位
创建 bigInt 可以在整数末尾添加n 或者调用 BigInt() 函数
let x = 999999999999999n;
let y = BitInt(23241232323123)

bigint 不能有小数


数字方法

toString() 将数字作为字符串返回
  tostring() 方法将数字作为字符串返回
toExponential() 返回以指数表示法书写的数字
toFixed() 返回带小数位数的数字
toPrecision 返回指定长度的数字
ValueOf() 以数字形式返回数字

在js中数字可以是原始值 typeof = number 或者对象 typeof=object
valueOf() 方法 在js内部用于将number对象转换为原始值
提示 所有的js数据类型都有valueof 和toString() 方法

将变量转换为数字
Number() 返回从其参数转换而来的数字
parseFloat() 解析其参数并返回浮点数
parseInt() 解析其参数并返回整数

Number(new Date("1970-01-01"))
Date() 方法 返回自1970年1月1日以来的毫秒数
parseInt() 解析字符串并返回整数。允许有空格。仅返回第一个数字：
parseInt("-10.33")
parseFloat() 解析字符串并返回数字。允许有空格。仅返回第一个数字：
parseFloat("10.33");
Number.isInteger()	如果参数是整数则返回 true。
Number.isSafeInteger()	如果参数是安全整数，则返回 true。
Number.parseFloat()	将字符串转换为数字。
Number.parseInt()	将字符串转换为整数。

什么是数组？
数组是一种特殊的变量，它能够一次存放一个以上的值。
数组可以用一个单一的名称存放很多值，并且还可以通过引用索引号来访问这些值。
var cars = ["Saab", "Volvo", "BMW"];
请不要最后一个元素之后写逗号（比如 "BMW",）。
使用 JavaScript 关键词 new

var cars = new Array("Saab", "Volvo", "BMW");

访问数组元素
通过引用索引号 下标号来引用某个数组元素
var name = cars[0];
数组是一种特殊类型的对象。在 JavaScript 中对数组使用 typeof 运算符会返回 "object"。
但是，JavaScript 数组最好以数组来描述。
数组使用数字来访问其“元素”。在本例中，person[0] 返回 Bill：

对象使用名称来访问其 成员 person.firstName 返回BILL
var person = {firstName:"Bill",lastName:"Gates",age:19}
document.getElementById("demo").innerHTML = person["firstName"];

JavaScript 变量可以是对象。数组是特殊类型的对象。
myArray[0] = Date.now;
myArray[1] = myFunction;
myArray[2] = myCars;
JavaScript 数组的真实力量隐藏在数组的属性和方法中：
var x = cars.length; //length 属性返回元素的数量
var y = cars.sort(); //sort() 方法对数组进行排序
访问第一个数组元素
实例
fruits = ["Banana", "Orange", "Apple", "Mango"];
var first = fruits[0];

访问最后一个数组元素
实例
fruits = ["Banana", "Orange", "Apple", "Mango"];
var last = fruits[fruits.length - 1];

遍历数组元素
遍历数组的最安全方法是使用 "for" 循环：

实例
var fruits, text, fLen, i;

fruits = ["Banana", "Orange", "Apple", "Mango"];
fLen = fruits.length;
text = "<ul>";
for (i = 0; i < fLen; i++) {
     text += "<li>" + fruits[i] + "</li>";
}

添加数组元素
向数组添加新元素的最佳方法是使用 push() 方法：

实例
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.push("Lemon");                // 向 fruits 添加一个新元素 (Lemon)


也可以使用 length 属性向数组添加新元素：

实例
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits[fruits.length] = "Lemon";     // 向 fruits 添加一个新元素 (Lemon)

添加最高索引的元素可在数组中创建未定义的“洞”：

实例
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits[6] = "Lemon";                 // 向 fruits 添加一个新元素 (Lemon)


数组和对象的区别
在 JavaScript 中，数组使用数字索引。
在 JavaScript 中，对象使用命名索引。
数组是特殊类型的对象，具有数字索引。

何时使用数组，何时使用对象？
JavaScript 不支持关联数组
如果希望元素名为字符串（文本）则应该使用对象。
如果希望元素名为数字则应该使用数组。

避免 new Array()
没有必要使用 JavaScript 的内建数组构造器 new Array()。

请使用 [] 取而代之！

下面两条不同的语句创建了名为 points 的新的空数组：

var points = new Array();         // 差
var points = [];                  // 优

下面两条不同的语句创建包含六个数字的新数组：

var points = new Array(40, 100, 1, 5, 25, 10); // 差
var points = [40, 100, 1, 5, 25, 10];          // 优

如何识别数组
常见的问题是：我如何知晓某个变量是否是数组？

问题在于 JavaScript 运算符 typeof 返回 "object"：

var fruits = ["Banana", "Orange", "Apple", "Mango"];
Array.isArray(fruits);     // 返回 true

创建您自己的 isArray() 函数以解决此问题：

function isArray(x) {
    return x.constructor.toString().indexOf("Array") > -1;
}

把数组转换为字符串 js方法 toString() 把数组转换为数组值 逗号分隔的字符串
var fruits = ["Banana", "Orange", "Apple", "Mango"];
document.getElementById("demo").innerHTML = fruits.toString();

join() 方法也可以将所有数组元素结合为一个字符串,它的行为类似 toString()  可以规定分配符
var fruits = ["Banana", "Orange","Apple", "Mango"];
document.getElementById("demo").innerHTML = fruits.join(" * ");


Popping 和 Pushing
在处理数组时，删除元素和添加新元素是很简单的。

Popping 和 Pushing 指的是：

从数组弹出项目，或向数组推入项目。

Popping
pop() 方法从数组中删除最后一个元素：

实例
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.pop();              // 从 fruits 删除最后一个元素（"Mango"）

pop() 方法返回“被弹出”的值：

实例
var fruits = ["Banana", "Orange", "Apple", "Mango"];
var x = fruits.pop();      // x 的值是 "Mango"

Pushing
push() 方法（在数组结尾处）向数组添加一个新的元素：

实例
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.push("Kiwi");       //  向 fruits 添加一个新元素


push() 方法返回新数组的长度：

实例
var fruits = ["Banana", "Orange", "Apple", "Mango"];
var x =  fruits.push("Kiwi");   //  x 的值是 5

位移元素
位移与弹出等同，但处理首个元素而不是最后一个。

shift() 方法会删除首个数组元素，并把所有其他元素“位移”到更低的索引。

实例
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.shift();            // 从 fruits 删除第一个元素 "Banana"

shift() 方法返回被“位移出”的字符串：

实例
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.shift();             // 返回 "Banana"


unshift() 方法（在开头）向数组添加新元素，并“反向位移”旧元素：

实例
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.unshift("Lemon");    // 向 fruits 添加新元素 "Lemon"

unshift() 方法返回新数组的长度。

实例
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.unshift("Lemon");    // 返回 5


更改元素
通过使用它们的索引号来访问数组元素：

数组索引（下标）以 0 开始。[0] 是第一个数组元素，[1] 是第二个，[2] 是第三个 ...

实例
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits[0] = "Kiwi";        // 把 fruits 的第一个元素改为 "Kiwi"

length 属性提供了向数组追加新元素的简易方法：

实例
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits[fruits.length] = "Kiwi";          // 向 fruits 追加 "Kiwi"


删除元素
既然 JavaScript 数组属于对象，其中的元素就可以使用 JavaScript delete 运算符来删除：

实例
var fruits = ["Banana", "Orange", "Apple", "Mango"];
delete fruits[0];           // 把 fruits 中的首个元素改为 undefined

拼接数组
splice() 方法可用于向数组添加新项：

实例
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.splice(2, 0, "Lemon", "Kiwi");

第一个参数（2）定义了应添加新元素的位置（拼接）。

第二个参数（0）定义应删除多少元素。

其余参数（“Lemon”，“Kiwi”）定义要添加的新元素。

splice() 方法返回一个包含已删除项的数组：

实例
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.splice(2, 2, "Lemon", "Kiwi");

使用 splice() 来删除元素
通过聪明的参数设定，您能够使用 splice() 在数组中不留“空洞”的情况下移除元素：

实例
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.splice(0, 1);        // 删除 fruits 中的第一个元素
第一个参数（0）定义新元素应该被添加（接入）的位置。

第二个参数（1）定义应该删除多个元素。

其余参数被省略。没有新元素将被添加。

合并（连接）数组
concat() 方法通过合并（连接）现有数组来创建一个新数组：

实例（合并两个数组）
var myGirls = ["Cecilie", "Lone"];
var myBoys = ["Emil", "Tobias", "Linus"];
var myChildren = myGirls.concat(myBoys);   // 连接 myGirls 和 myBoys

concat() 方法不会更改现有数组。它总是返回一个新数组。

concat() 方法可以使用任意数量的数组参数：

实例（合并三个数组）
var arr1 = ["Cecilie", "Lone"];
var arr2 = ["Emil", "Tobias", "Linus"];
var arr3 = ["Robin", "Morgan"];
var myChildren = arr1.concat(arr2, arr3);   // 将arr1、arr2 与 arr3 连接在一起

concat() 方法也可以将值作为参数：

实例（将数组与值合并）
var arr1 = ["Cecilie", "Lone"];
var myChildren = arr1.concat(["Emil", "Tobias", "Linus"]);

裁剪数组
slice() 方法用数组的某个片段切出新数组。

本例从数组元素 1 （"Orange"）开始切出一段数组：

实例
var fruits = ["Banana", "Orange", "Lemon", "Apple", "Mango"];
var citrus = fruits.slice(1);

slice() 方法创建新数组。它不会从源数组中删除任何元素。

本例从数组元素 3 （"Apple"）开始切出一段数组：

实例
var fruits = ["Banana", "Orange", "Lemon", "Apple", "Mango"];
var citrus = fruits.slice(3);

slice() 可接受两个参数，比如 (1, 3)。

该方法会从开始参数选取元素，直到结束参数（不包括）为止。

实例
var fruits = ["Banana", "Orange", "Lemon", "Apple", "Mango"];
var citrus = fruits.slice(1, 3);

sort() 方法 以字母顺序对数组进行排序

var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.sort();

reverse() 反转数组中的元素 使用它降序对数组进行排序
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.sort();            // 对 fruits 中的元素进行排序
fruits.reverse();         // 反转元素顺序

数字排序 默认sort() 函数 按照字符串顺序对值进行排序
var points = [40, 100, 1, 5, 25, 10];
points.sort(function(a, b){return a - b});


对数组进行降序排序
var points = [40, 100, 1, 5, 25, 10];
points.sort(function(a, b){return b -a});

比值函数
比较函数的目的是定义另外一种排序顺序
比较函数应该返回一个负,零或正值 取决于参数
function(a,b){return a-b}

当 sort() 函数比较两个值时,会将值发送到比较函数,并根据所返回的值对这些值进行排序
实例：
当比较 40 和 100 时，sort() 方法会调用比较函数 function(40,100)。

该函数计算 40-100，然后返回 -60（负值）。

排序函数将把 40 排序为比 100 更低的值。

您可以使用下面的代码片段来测试数值和字母排序：

数组迭代方法对每个数组项进行操作
Array.forEach() 方法为每个数组元素调用一次函数 回调函数
Array.map()
  map() 方法通过对每个数组元素执行函数来创建新数组
  map() 方法不会对没有值的数组元素执行函数
  map() 方法不会更改原始数组


Array.filter() 方法创建一个包含通过测试的数组元素的新数组
Array.reduce()
reduce() 方法在每个数组元素上运行函数，以生成（减少它）单个值。

reduce() 方法在数组中从左到右工作。另请参阅 reduceRight()。

reduce() 方法不会减少原始数组。
reduce() 方法能够接受一个初始值：
var numbers1 = [45, 4, 9, 16, 25];
var sum = numbers1.reduce(myFunction, 100);

function myFunction(total, value) {
  return total + value;
}

Array.reduce() 和 Array.reduceRight() 都是 JavaScript 数组方法，用于将数组元素缩减为单个值。它们的主要区别在于处理数组的方向不同。

Array.reduce()
reduce() 方法从数组的第一个元素开始执行回调函数，向后遍历直到最后一个元素。这意味着它按照数组元素的自然顺序（从左到右）进行操作。

Javascript
深色版本
1const numbers = [1, 2, 3, 4, 5];
2const sum = numbers.reduce((accumulator, currentValue) => accumulator + currentValue, 0);
3console.log(sum); // 输出：15
在这个例子中，reduce() 从第一个元素 1 开始，逐步向后累加每个元素的值。

Array.reduceRight()
与此相反，reduceRight() 方法从数组的最后一个元素开始执行回调函数，向前遍历直到第一个元素。也就是说，它按照数组元素的逆序（从右到左）进行操作。

Javascript
深色版本
1const numbers = [1, 2, 3, 4, 5];
2const product = numbers.reduceRight((accumulator, currentValue) => accumulator * currentValue, 1);
3console.log(product); // 输出：120
在这个例子中，reduceRight() 从最后一个元素 5 开始，逐步向前乘以每个元素的值。

总结
reduce() 按照数组元素的自然顺序（从左到右）进行累积。
reduceRight() 按照数组元素的逆序（从右到左）进行累积。


Array.every()
every() 方法检查所有数组值是否通过测试。

这个例子检查所有数组值是否大于 18：

实例
var numbers = [45, 4, 9, 16, 25];
var allOver18 = numbers.every(myFunction);

function myFunction(value, index, array) {
  return value > 18;
}

Array.every() 和 Array.filter() 是 JavaScript 中数组的两个非常有用的方法，但它们的用途和返回值类型完全不同。

Array.every()
every() 方法用于检查数组的所有元素是否都满足提供的测试函数。如果所有元素都能使测试函数返回 true，则 every() 返回 true；否则返回 false。这是一个布尔判断方法，最终只会返回一个布尔值。

例子：
Javascript
深色版本
1const numbers = [2, 4, 6, 8];
2
3const allEven = numbers.every(number => number % 2 === 0);
4console.log(allEven); // 输出: true
5
6const mixedNumbers = [2, 4, 5, 8];
7const allEvenAgain = mixedNumbers.every(number => number % 2 === 0);
8console.log(allEvenAgain); // 输出: false
Array.filter()
filter() 方法用于创建一个新数组，其包含通过测试函数的数组的所有元素。换句话说，filter() 会返回一个新数组，其中包含原数组中所有使得测试函数返回 true 的元素。

例子：
Javascript
深色版本
1const numbers = [1, 2, 3, 4, 5, 6];
2
3const evenNumbers = numbers.filter(number => number % 2 === 0);
4console.log(evenNumbers); // 输出: [2, 4, 6]
总结
every() 用于检查数组中的所有元素是否满足某个条件，返回一个布尔值。
filter() 用于筛选出满足条件的元素并返回一个新的数组。
这两个方法虽然都接受一个测试函数作为参数，但 every() 关注的是整体属性（所有元素是否满足条件），而 filter() 关注的是个体属性（哪些元素满足条件），并返回满足条件的元素组成的新数组。

Array.some()
some() 方法检查某些数组值是否通过了测试。

这个例子检查某些数组值是否大于 18：

实例
var numbers = [45, 4, 9, 16, 25];
var someOver18 = numbers.some(myFunction);

function myFunction(value, index, array) {
  return value > 18;
}

Array.indexOf()
indexOf() 方法在数组中搜索元素值并返回其位置。

注释：第一个项目的位置是 0，第二个项目的位置是 1，以此类推。

实例
检索数组中的项目 "Apple"：

var fruits = ["Apple", "Orange", "Apple", "Mango"];
var a = fruits.indexOf("Apple");

Array.some() 和 Array.every() 都是 JavaScript 中用于数组的迭代方法，它们用于基于提供的测试函数检查数组元素的状态，但它们的逻辑和返回值有所不同。

Array.some()
some() 方法检查数组中是否有至少一个元素满足由提供的函数定义的条件。如果有任何元素使测试函数返回 true，some() 将立即返回 true。如果数组中没有任何元素满足条件，则返回 false。

例子：
Javascript
深色版本
1const numbers = [1, 3, 5, 7, 8, 9];
2
3const hasEvenNumber = numbers.some(number => number % 2 === 0);
4console.log(hasEvenNumber); // 输出: true
5
6const allOddNumbers = [1, 3, 5, 7];
7const noEvenNumber = allOddNumbers.some(number => number % 2 === 0);
8console.log(noEvenNumber); // 输出: false
Array.every()
every() 方法检查数组中的所有元素是否都满足由提供的函数定义的条件。只有当所有元素都使测试函数返回 true 时，every() 才会返回 true。如果任何元素不满足条件，则返回 false。

例子：
Javascript
深色版本
1const numbers = [2, 4, 6, 8];
2
3const allEven = numbers.every(number => number % 2 === 0);
4console.log(allEven); // 输出: true
5
6const mixedNumbers = [2, 4, 5, 8];
7const notAllEven = mixedNumbers.every(number => number % 2 === 0);
8console.log(notAllEven); // 输出: false
总结
some() 只需找到一个符合条件的元素即返回 true。
every() 需要所有元素都符合条件才返回 true。
因此，some() 通常用于确认数组中是否存在满足特定条件的元素，而 every() 则用于验证数组中的所有元素是否都满足某个共同的条件。

Array.indexOf()
indexOf() 方法在数组中搜索元素值并返回其位置。

注释：第一个项目的位置是 0，第二个项目的位置是 1，以此类推。

实例
检索数组中的项目 "Apple"：

var fruits = ["Apple", "Orange", "Apple", "Mango"];
var a = fruits.indexOf("Apple");

Array.lastIndexOf()
Array.lastIndexOf() 与 Array.indexOf() 类似，但是从数组结尾开始搜索。

实例
检索数组中的项目 "Apple"：

var fruits = ["Apple", "Orange", "Apple", "Mango"];
var a = fruits.lastIndexOf("Apple");

Array.find()
find() 方法返回通过测试函数的第一个数组元素的值。

这个例子查找（返回）大于 18 的第一个元素的值：

实例
var numbers = [4, 9, 16, 25, 29];
var first = numbers.find(myFunction);

function myFunction(value, index, array) {
  return value > 18;
}

Array.find() 和 Array.indexOf() 都是JavaScript中用于在数组中搜索特定元素的方法，但它们的工作方式和返回值类型有显著的不同。

Array.find()
find() 方法返回数组中满足提供的测试函数的第一个元素的值。换句话说，它会遍历数组，并对每个元素应用测试函数。一旦找到第一个使测试函数返回 true 的元素，find() 就会立即停止遍历并返回该元素。如果没有找到满足条件的元素，find() 将返回 undefined。

例子：
Javascript
深色版本
1const numbers = [1, 3, 5, 8, 10];
2
3const firstEvenNumber = numbers.find(number => number % 2 === 0);
4console.log(firstEvenNumber); // 输出: 8
Array.indexOf()
indexOf() 方法返回在数组中找到的第一个指定元素的索引，如果未找到元素则返回 -1。这个方法不需要提供测试函数，而是直接比较元素值。

例子：
Javascript
深色版本
1const numbers = [1, 3, 5, 8, 10];
2
3const index = numbers.indexOf(8);
4console.log(index); // 输出: 3
总结
find() 返回满足条件的第一个元素的值，如果没有找到则返回 undefined。
indexOf() 返回指定元素的索引，如果没有找到则返回 -1。
选择使用哪个方法
当你关心的是找到满足特定条件的第一个元素本身时，应该使用 find()。当你需要知道特定值在数组中的位置（索引）时，应使用 indexOf()。如果需要查找最后一个匹配项的位置，可以使用 lastIndexOf()，它类似于 indexOf()，但反向搜索数组。

find() 和 indexOf() 在功能上并不完全重叠，它们各自解决不同类型的问题，选择使用哪一个取决于你的具体需求。

Array.findIndex()
findIndex() 方法返回通过测试函数的第一个数组元素的索引。

这个例子查找大于 18 的第一个元素的索引：

实例
var numbers = [4, 9, 16, 25, 29];
var first = numbers.findIndex(myFunction);

function myFunction(value, index, array) {
  return value > 18;
}



-->
<body>
<p>插值替换</p>
<p id="demo"></p>
<p id="demo1"></p>
<p id="demo2"></p>
<p id="demo3"></p>
<p id="demo4"></p>
<p id="demo5"></p>
<p id="demo6"></p>
<p id="demo7"></p>
<button onclick="myFunction1()">以字母顺序排序</button>
<button onclick="myFunction2()">以数字顺序排序</button>
<button onclick="myFunction3()">以随机顺序排序</button>
<button onclick="myFunction4()">查找最高/最低的数组值</button>
<p id="demo8"></p>
<p>最高值是：<span id="demo9"></span></p>
<p>最高值是：<span id="demo11"></span></p>
<p>最小值是：<span id="demo10"></span></p>
<p>最小值是：<span id="demo12"></span></p>
<br>
<button onclick="sortYear()">排序</button>
<p id="demo13"></p>
<br>
<p>为每个元素调用一次函数</p>
<p id="demo14"></p>

<p>使用map函数进行创建新的数组</p>
<p id="demo15"></p>

<p>使用filter创建一个新的数组</p>
<p id="demo16"></p>

<p>使reduce创建一个新的数组</p>
<p id="demo17"></p>

<p>使reduceRight创建一个新的数组</p>
<p id="demo18"></p>

<script>
  //map创建数组
  var number1 = [6, 8, 77, 87, 68, 64, 54]
  var number2 = number1.map(
    // 箭头函数 const functionName = parameter =>  {函数体}; 当参数只有一个时,括号也可以省略
    myFunction6 = (value) => {
      return value * 2
    }
  );
  document.getElementById("demo15").innerHTML = number2

  // 获取数组中所有数字的和 从左到右
  var sum1 = number1.reduce(myFunction7 = (total, value) => {
    return total + value
  })
  document.getElementById("demo17").innerHTML = sum1;

  // 获取数组中所有数字的和 从右到左
  var sum2 = number1.reduceRight(myFunction8 = (total, value) => {
    return total + value
  })
  document.getElementById("demo18").innerHTML = sum2;

  // 使用filter 创建一个新的数组
  var over18 = number1.filter(muFunction7 = (value) => {
    return value > 18
  });
  document.getElementById("demo16").innerHTML = over18;


  var txt1 = "";
  var numbers = [45, 8, 83, 43, 6, 4, 56]
  numbers.forEach(myFunction5);
  document.getElementById("demo14").innerHTML = txt1;

  // 循环调用元素
  function myFunction5(value, index, array) {
    txt1 = txt1 + value + "<br>";
  }

  var points = [40, 100, 1, 5, 25, 10];
  document.getElementById("demo8").innerHTML = points;

  // 以字母排序
  function myFunction1() {
    points.sort();
    document.getElementById("demo8").innerHTML = points;
  }

  // 以数字排序
  function myFunction2() {
    points.sort(function (a, b) {
      return a - b
    });
    document.getElementById("demo8").innerHTML = points;
  }

  // 随机排序
  function myFunction3() {
    points.sort(function (a, b) {
      return 0.5 - Math.random()
    });
    document.getElementById("demo8").innerHTML = points;
  }

  // 查找最高或最低的数组值
  function myFunction4() {
    points.sort(function (a, b) {
      return a - b
    });
    // 最高值
    text = points[points.length - 1]
    document.getElementById("demo8").innerHTML = text;
  }

  // 对数字使用Math.max() 可以使用math.max.apply 来查找数组中的最高值
  function myArrayMax(arr) {
    return Math.max.apply(null, arr);
  }

  document.getElementById("demo9").innerHTML = myArrayMax(points)

  // 对数字使用Math.min() 可以使用math.min.apply 来查找数组中的最小值
  function myArrayMin(arr) {
    return Math.min.apply(null, arr);
  }

  document.getElementById("demo10").innerHTML = myArrayMin(points)

  // 自定义 函数遍历数组,用找到的最高值与每个值进行比较
  function myArrayMax1(arr) {
    var len = arr.length
    var max = -Infinity;
    while (len--) {
      if (arr[len] > max) {
        max = arr[len];
      }
    }
    return max;
  }

  document.getElementById("demo11").innerHTML = myArrayMax1(points)

  // 自定义 函数遍历数组,用找到的最高值与每个值进行比较
  function myArrayMin1(arr) {
    var len = arr.length
    var min = Infinity;
    while (len--) {
      if (arr[len] < min) {
        min = arr[len];
      }
    }
    return min;
  }

  document.getElementById("demo12").innerHTML = myArrayMin1(points)

  // 排序对象数组
  var cars1 = [{type: "Volvo", year: 2016},
    {type: "Saab", year: 2001},
    {type: "BMW", year: 2010}];

  displayCars();

  function sortYear() {
    cars1.sort(function (a, b) {
      return a.year - b.year
    });
    displayCars();
  }

  function displayCars() {
    document.getElementById("demo13").innerHTML =
      cars1[0].type + " " + cars1[0].year + "<br>" +
      cars1[1].type + " " + cars1[1].year + "<br>" +
      cars1[2].type + " " + cars1[2].year;
  }

  let firstName = "Jin";
  let lastName = "Ran";
  let price = 10;
  let VAT = 0.25;
  var cars = ["Saab", "Volvo", "BMW"];
  document.getElementById("demo6").innerHTML = cars[0];
  // let header = "Templates Literals";
  // let tags = ["template literals", "javascript", "es6"]
  // let html = '<h2> ${header} </h2><ul>';
  // for (const x of tags){
  //   html+='<li> ${x} </li>';
  // }
  // html +='</ul>';
  let x = 123;
  let y = 9.5634;
  let z = 9.4552;
  document.getElementById("demo2").innerHTML = x.toString() + "<br>" + (123).toString() + "<br>" + (100 + 23).toString();
  document.getElementById("demo3").innerHTML = y.toExponential(2);
  // toFixed(2) 返回一个字符串,其中数字带有指定位数的小数部分
  document.getElementById("demo4").innerHTML = z.toFixed(2);
  // toPrecision() 方法 返回一个字符串,其中包含指定长度的数字  和toFixed的区别在于一个是返回小数点后几位,一个是一共返回多少位数字,不管小数点
  document.getElementById("demo5").innerHTML = z.toPrecision(2)
  let text = `Welcome ${firstName},${lastName}!`;
  let total = `Total:${(price * (1 + VAT)).toFixed(2)}`
  document.getElementById("demo").innerHTML = text;
  document.getElementById("demo1").innerHTML = total;
  // document.getElementById("demo2").innerHTML=html;
  var fruits, text1;
  fruits = ["Banana", "Orange", "Apple", "Mango"];
  text1 = "<ul>";
  fruits.forEach(myFunction);
  text1 += "</ul>";
  document.getElementById("demo7").innerHTML = text1;

  function myFunction(value) {
    text1 += "<li>" + value + "</li>";
  }

</script>
</body>
</html>
